home *** CD-ROM | disk | FTP | other *** search
/ EnigmA Amiga Run 1996 February / EnigmA AMIGA RUN 04 (1996)(G.R. Edizioni)(IT)[!][issue 1996-02][Skylink CD III].iso / earcd / program / wkmc.lha / wkmc / src / wkmc.h < prev   
C/C++ Source or Header  |  1995-10-23  |  9KB  |  408 lines
  1. /*
  2.  
  3.  wkmc is a simple true-color-display using a 8-bit-screen,
  4.  the idea behind this came from Stefan Kost and Smack/IFT
  5.  
  6.  NOTE: I think it's fast beeing pure C !
  7.  
  8.  
  9.  Advantages (compared against MultiColor):
  10.   -terrible high speed
  11.   -picture-size and -aspect isn't changed
  12.   -no ugly diagonal-dithering
  13.   -no flickering (uses Multiscan)
  14.   -uses all 256 registers (not only 255)
  15.   -every color-channel (RGB) has a diffent number of
  16.    shades ("eye-sensitive")
  17. */
  18.  
  19.  
  20. /* start independant mc-stuff */
  21. #include <stdio.h>
  22. #include <stdlib.h>
  23. #include <string.h>
  24. #include <exec/types.h>
  25. #include <graphics/displayinfo.h>
  26. #include <intuition/intuition.h>
  27. #include <time.h>
  28. static double tm,dt;
  29. static time_t tm1,tm2;
  30.  
  31. #ifdef __GNUC__
  32. #else
  33.  #include <clib/exec_protos.h>
  34.  #include <clib/graphics_protos.h>
  35.  #include <clib/intuition_protos.h>
  36. #endif
  37.  
  38. struct GfxBase *GfxBase=NULL;
  39. struct IntuitionBase *IntuitionBase=NULL;
  40. struct Screen *theScreen=NULL;
  41. struct Window *theWindow=NULL;
  42. struct RastPort *rp=NULL;
  43.  
  44. static ULONG ct[770],cvals[256];
  45. static UBYTE pt[256],rt[256],gt[256],bt[256],rbit[256][8],gbit[256][8],bbit[256][8];
  46. static UBYTE entry[9];
  47. static ULONG ind;
  48. static double f256=1.0/256.0;
  49.  
  50. void cleanup(void) {
  51.  if(theWindow!=NULL) {CloseWindow(theWindow);theWindow=NULL;}
  52.  if(theScreen!=NULL) {CloseScreen(theScreen);theScreen=NULL;}
  53.  if(GfxBase!=NULL) {CloseLibrary((struct Library*)GfxBase);GfxBase=NULL;}
  54.  if(IntuitionBase!=NULL) {CloseLibrary((struct Library*)IntuitionBase);IntuitionBase=NULL;}
  55. }
  56.  
  57. UBYTE getbit(UBYTE val,UBYTE bit) {
  58.  if(bit!=0) return((val>>bit)%2);
  59.  else return(val%2);
  60. }
  61.  
  62. int init(int width,int height) {
  63.  int i,rs=76,gs=150,bs=30;
  64.  float cscl,cl,cmode=1;
  65.  ULONG lval,lv;
  66.  UBYTE j;
  67.  GfxBase=(struct GfxBase *)OpenLibrary("graphics.library",39L);
  68.  if(GfxBase==NULL) {printf(" Couldn't open graphics.library V39+.\n");return(1);}
  69.  IntuitionBase=(struct IntuitionBase *) OpenLibrary("intuition.library",39L);
  70.  if(IntuitionBase==NULL) {printf(" Couldn't open intuition.library V39+.\n");cleanup();return(2);}
  71.  
  72.  if(cmode==0) {
  73.   rs=85;gs=86;bs=85;
  74.  }
  75.  else if(cmode==1) {
  76.   rs=76,gs=150,bs=30;
  77.  }
  78.  
  79.  ct[0]=(ULONG)256<<16;ct[769]=0;
  80.  lval=1;
  81.  
  82.  cscl=256.0/(float)rs;
  83.  for(i=0;i<rs;i++) {
  84.   cl=(float)i*cscl+0.5;
  85.   lv=(ULONG)cl;if(lv>255) lv=255;
  86.   cvals[i]=lv;
  87.   pt[i]=lv;
  88.  }  
  89.  for(i=0;i<rs;i++) {
  90.   ct[lval]=cvals[i]<<24;lval++;
  91.   ct[lval]=0;lval++;
  92.   ct[lval]=0;lval++;
  93.  }
  94.  
  95.  cscl=256.0/(float)gs;
  96.  for(i=0;i<gs;i++) {
  97.   cl=(float)i*cscl+0.5;
  98.   lv=(ULONG)cl;if(lv>255) lv=255;
  99.   cvals[i]=lv;
  100.   pt[i+rs]=lv;
  101.  }
  102.  for(i=0;i<gs;i++) {
  103.   ct[lval]=0;lval++;
  104.   ct[lval]=cvals[i]<<24;lval++;
  105.   ct[lval]=0;lval++;
  106.  }
  107.  
  108.  cscl=256.0/(float)bs;
  109.  for(i=0;i<bs;i++) {
  110.   cl=(float)i*cscl+0.5;
  111.   lv=(ULONG)cl;if(lv>255) lv=255;
  112.   cvals[i]=lv;
  113.   pt[i+rs+gs]=lv;
  114.  }
  115.  for(i=0;i<bs;i++) {
  116.   ct[lval]=0;lval++;
  117.   ct[lval]=0;lval++;
  118.   ct[lval]=cvals[i]<<24;lval++;
  119.  }
  120.  
  121.  cscl=(float)rs/256.0;
  122.  for(i=0;i<256;i++) {
  123.   cl=(float)i*cscl+0.5;
  124.   lval=(ULONG)cl;if(lval>(rs-1)) lval=rs-1;
  125.   rt[i]=(UBYTE)lval;
  126.  }
  127.  
  128.  cscl=(float)gs/256.0;
  129.  for(i=0;i<256;i++) {
  130.   cl=(float)i*cscl+0.5;
  131.   lval=(ULONG)cl;if(lval>(gs-1)) lval=gs-1;
  132.   gt[i]=(UBYTE)lval+(UBYTE)rs;
  133.  }
  134.  
  135.  cscl=(float)bs/256.0;
  136.  for(i=0;i<256;i++) {
  137.   cl=(float)i*cscl+0.5;
  138.   lval=(ULONG)cl;if(lval>(bs-1)) lval=bs-1;
  139.   bt[i]=(UBYTE)lval+(UBYTE)rs+(UBYTE)gs;
  140.  }
  141.  
  142.  for(i=0;i<256;i++) {
  143.   for(j=0;j<8;j++) {
  144.    rbit[i][j]=getbit(rt[i],j);
  145.    gbit[i][j]=getbit(gt[i],j);
  146.    bbit[i][j]=getbit(bt[i],j);
  147.   }
  148.  }
  149.  
  150.  theScreen=(struct Screen*)OpenScreenTags(NULL,
  151.   SA_DisplayID,(ULONG)0x39024,
  152.   SA_Overscan,OSCAN_TEXT,
  153.   SA_Width,width,
  154.   SA_Height,height,
  155.   SA_Depth,8,
  156.   SA_AutoScroll,1,
  157.   SA_Title,"WKMC-Screen",
  158.   SA_Colors32,ct,
  159.   TAG_DONE);
  160.  if(theScreen==NULL) {printf(" Couln't open screen.\n");cleanup();return(3);}
  161.  theWindow=(struct Window*)OpenWindowTags(NULL,
  162.   WA_Left,0,
  163.   WA_Top,0,
  164.   WA_Width,width,
  165.   WA_Height,height,
  166.   WA_MinWidth,50,
  167.   WA_MinHeight,40,
  168.   WA_MaxWidth,-1,
  169.   WA_MaxHeight,-1,
  170.   WA_IDCMP,VANILLAKEY,
  171.   WA_SizeGadget,FALSE,
  172.   WA_DepthGadget,FALSE,
  173.   WA_DragBar,FALSE,
  174.   WA_CloseGadget,FALSE,
  175.   WA_Borderless,TRUE,
  176.   WA_NoCareRefresh,TRUE,
  177.   WA_SmartRefresh,TRUE,
  178.   WA_CustomScreen,theScreen,
  179.   WA_Activate,TRUE,
  180.   TAG_DONE);
  181.  if(theWindow==NULL) {printf(" Couldn't open window.\n");cleanup();return(4);}
  182.  rp=theWindow->RPort;
  183.  return(0);
  184. }
  185.  
  186. void SetPixelS(int x,int y,UBYTE r,UBYTE g,UBYTE b) {
  187.  if((x%2==0) && (y%2==0)) {
  188.   SetAPen(rp,rt[r]);
  189.   WritePixel(rp,x,y); 
  190.   SetAPen(rp,gt[g]);
  191.   WritePixel(rp,x+1,y);
  192.   SetAPen(rp,bt[b]);
  193.   if(y%4==0) WritePixel(rp,x,y+1);
  194.   else WritePixel(rp,x+1,y+1); 
  195.  }
  196. }
  197.  
  198. void SetPixel(int x,int y,UBYTE r,UBYTE g,UBYTE b) {
  199.  register int xx,yy;
  200.  xx=x+x;yy=y+y;
  201.  SetAPen(rp,rt[r]);
  202.  WritePixel(rp,xx,yy);
  203.  SetAPen(rp,gt[g]);
  204.  WritePixel(rp,xx+1,yy);
  205.  SetAPen(rp,bt[b]);
  206.  if(yy%4==0) WritePixel(rp,xx,yy+1);
  207.  else WritePixel(rp,xx+1,yy+1);
  208. }
  209.  
  210.  
  211. void GetPixel(int x,int y,UBYTE *r,UBYTE *g,UBYTE *b) {
  212.  register int xx,yy;
  213.  xx=x+x;yy=y+y;
  214.  (*r)=pt[ReadPixel(rp,xx,yy)];
  215.  (*g)=pt[ReadPixel(rp,xx+1,yy)];
  216.  if(yy%4==0) (*b)=pt[ReadPixel(rp,xx,yy+1)];
  217.  else (*b)=pt[ReadPixel(rp,xx+1,yy+1)];
  218. }
  219.  
  220. void SetLine(int i,UBYTE* line,int width,int bn,UBYTE **bl) {
  221.  register int k,act,l,act3,ii;
  222.  ii=i+i;
  223.  
  224.  /* rg */
  225.  act=0;
  226.  for(k=0;k<bn;k++) {
  227.   act3=act+act+act;
  228.   for(l=0;l<8;l++) {
  229.    entry[l]=rbit[line[act3]][l]<<7;
  230.    entry[l]+=gbit[line[act3+1]][l]<<6;
  231.   }
  232.   act++;
  233.   act3=act+act+act;
  234.   for(l=0;l<8;l++) {
  235.    entry[l]+=rbit[line[act3]][l]<<5;
  236.    entry[l]+=gbit[line[act3+1]][l]<<4;
  237.   }
  238.   act++;
  239.   act3=act+act+act;
  240.   for(l=0;l<8;l++) {
  241.    entry[l]+=rbit[line[act3]][l]<<3;
  242.    entry[l]+=gbit[line[act3+1]][l]<<2;
  243.   }
  244.   act++;
  245.   act3=act+act+act;
  246.   for(l=0;l<8;l++) {
  247.    entry[l]+=rbit[line[act3]][l]<<1;
  248.    entry[l]+=gbit[line[act3+1]][l];
  249.   }
  250.   act++;
  251.   for(l=0;l<8;l++) bl[l][k]=entry[l];
  252.  }
  253.  ind=(ULONG)ii*(ULONG)bn;
  254.  for(k=0;k<8;k++) memcpy(&(theScreen->BitMap.Planes[k][ind]),bl[k],bn);
  255.  
  256.  /* b */
  257.  if(i%4==0) {
  258.   act=0;
  259.   for(k=0;k<bn;k++) {
  260.    act3=act+act+act+2;
  261.    for(l=0;l<8;l++) {
  262.     entry[l]=bbit[line[act3]][l]<<7;
  263.    }
  264.    act++;
  265.    act3=act+act+act+2;
  266.    for(l=0;l<8;l++) {
  267.     entry[l]+=bbit[line[act3]][l]<<5;
  268.    }
  269.    act++;
  270.    act3=act+act+act+2;
  271.    for(l=0;l<8;l++) {
  272.     entry[l]+=bbit[line[act3]][l]<<3;
  273.    }
  274.    act++;
  275.    act3=act+act+act+2;
  276.    for(l=0;l<8;l++) {
  277.     entry[l]+=bbit[line[act3]][l]<<1;
  278.    }
  279.    act++;
  280.    for(l=0;l<8;l++) bl[l][k]=entry[l];
  281.   }
  282.  }
  283.  else {
  284.   act=0;
  285.   for(k=0;k<bn;k++) {
  286.    act3=act+act+act+2;
  287.    for(l=0;l<8;l++) {
  288.     entry[l]=bbit[line[act3]][l]<<6;
  289.    }
  290.    act++;
  291.    act3=act+act+act+2;
  292.    for(l=0;l<8;l++) {
  293.     entry[l]+=bbit[line[act3]][l]<<4;
  294.    }
  295.    act++;
  296.    act3=act+act+act+2;
  297.    for(l=0;l<8;l++) {
  298.     entry[l]+=bbit[line[act3]][l]<<2;
  299.    }
  300.    act++;
  301.    act3=act+act+act+2;
  302.    for(l=0;l<8;l++) {
  303.     entry[l]+=bbit[line[act3]][l];
  304.    }
  305.    act++;
  306.    for(l=0;l<8;l++) bl[l][k]=entry[l];
  307.   }
  308.  }
  309.  ind+=(ULONG)bn;
  310.  for(k=0;k<8;k++) memcpy(&(theScreen->BitMap.Planes[k][ind]),bl[k],bn);
  311. }
  312.  
  313. void SetLineS(int i,UBYTE *line,int width,int bn,UBYTE **bl) {
  314.  register int k,act,l,act3;
  315.  if(i%2!=0) return;
  316.  
  317.  /* rg */
  318.  
  319.  act=0;
  320.  for(k=0;k<bn;k++) {
  321.   act3=act+act+act;
  322.   for(l=0;l<8;l++) {
  323.    entry[l]=rbit[line[act3]][l]<<7;
  324.    entry[l]+=gbit[line[act3+1]][l]<<6;
  325.   }
  326.   act+=2;
  327.   act3=act+act+act;
  328.   for(l=0;l<8;l++) {
  329.    entry[l]+=rbit[line[act3]][l]<<5;
  330.    entry[l]+=gbit[line[act3+1]][l]<<4;
  331.   }
  332.   act+=2;
  333.   act3=act+act+act;
  334.   for(l=0;l<8;l++) {
  335.    entry[l]+=rbit[line[act3]][l]<<3;
  336.    entry[l]+=gbit[line[act3+1]][l]<<2;
  337.   }
  338.   act+=2;
  339.   act3=act+act+act;
  340.   for(l=0;l<8;l++) {
  341.    entry[l]+=rbit[line[act3]][l]<<1;
  342.    entry[l]+=gbit[line[act3+1]][l];
  343.   }
  344.   act+=2;
  345.   for(l=0;l<8;l++) bl[l][k]=entry[l];
  346.  }
  347.  ind=(ULONG)i*(ULONG)bn;
  348.  for(k=0;k<8;k++) memcpy(&(theScreen->BitMap.Planes[k][ind]),bl[k],bn);
  349.  
  350.  /* b */
  351.  if(i%4==0) {
  352.   act=0;
  353.   for(k=0;k<bn;k++) {
  354.    act3=act+act+act+2;
  355.    for(l=0;l<8;l++) {
  356.     entry[l]=bbit[line[act3]][l]<<7;
  357.    }
  358.    act+=2;
  359.    act3=act+act+act+2;
  360.    for(l=0;l<8;l++) {
  361.     entry[l]+=bbit[line[act3]][l]<<5;
  362.    }
  363.    act+=2;
  364.    act3=act+act+act+2;
  365.    for(l=0;l<8;l++) {
  366.     entry[l]+=bbit[line[act3]][l]<<3;
  367.    }
  368.    act+=2;
  369.    act3=act+act+act+2;
  370.    for(l=0;l<8;l++) {
  371.     entry[l]+=bbit[line[act3]][l]<<1;
  372.    }
  373.    act+=2;
  374.    for(l=0;l<8;l++) bl[l][k]=entry[l];
  375.   }
  376.  }
  377.  else {
  378.   act=0;
  379.   for(k=0;k<bn;k++) {
  380.    act3=act+act+act+2;
  381.    for(l=0;l<8;l++) {
  382.     entry[l]=bbit[line[act3]][l]<<6;
  383.    }
  384.    act+=2;
  385.    act3=act+act+act+2;
  386.    for(l=0;l<8;l++) {
  387.     entry[l]+=bbit[line[act3]][l]<<4;
  388.    }
  389.    act+=2;
  390.    act3=act+act+act+2;
  391.    for(l=0;l<8;l++) {
  392.     entry[l]+=bbit[line[act3]][l]<<2;
  393.    }
  394.    act+=2;
  395.    act3=act+act+act+2;
  396.    for(l=0;l<8;l++) {
  397.     entry[l]+=bbit[line[act3]][l];
  398.    }
  399.    act+=2;
  400.    for(l=0;l<8;l++) bl[l][k]=entry[l];
  401.   }
  402.  }
  403.  ind+=(ULONG)bn;
  404.  for(k=0;k<8;k++) memcpy(&(theScreen->BitMap.Planes[k][ind]),bl[k],bn);
  405. }
  406.  
  407. /* end independant mc-stuff */
  408.